1// JDK 给 Collection 加了 stream()，如果不加 default，
2// 所有 List/Set/Queue 的子类全部要改，灾难级别。
3interface Collection<E> {
4    default Stream<E> stream() {
5        return StreamSupport.stream(spliterator(), false);
6    }
7}

1// ❌ 错误：接口的 default 方法不能调用 Object 的方法（编译报错）
2interface Foo {
3    default String toString() {  // ❌ 编译错误！
4        return "Foo";
5    }
6}
7// 原因：Object 的 toString/hashCode/equals 是"最终仲裁者"，
8// 接口 default 不允许覆盖它们，否则继承链混乱。

1// ❌ 错误：两个接口有同名 default 方法，实现类必须手动解决冲突
2interface A { default void say() { System.out.println("A"); } }
3interface B { default void say() { System.out.println("B"); } }
4
5class C implements A, B {
6    // ❌ 编译错误！必须重写 say()
7    // ✅ 正确做法：
8    @Override
9    public void say() {
10        A.super.say();  // 显式指定调用哪个
11    }
12}

1interface MyInterface {
2    static void hello() { System.out.println("hello"); }
3}
4
5class MyClass implements MyInterface {
6    void test() {
7        // MyClass.hello();  // ❌ 编译错误
8        MyInterface.hello(); // ✅ 正确
9    }
10}

1// ✅ 合法（不加注解也能用于 Lambda）
2interface Converter {
3    String convert(Integer i);
4}
5
6// ✅ 推荐写法（加注解让编译器替你盯着）
7@FunctionalInterface
8interface Converter {
9    String convert(Integer i);
10    // 可以加 default 和 static 方法，不破坏"单一抽象方法"规则
11    default String defaultConvert(Integer i) { return String.valueOf(i); }
12}

1// ❌ 错误：两个抽象方法
2@FunctionalInterface
3interface Broken {         // ❌ 编译报错！
4    void doA();
5    void doB();
6}
7
8// ❌ 错误：但很容易不经意犯错——比如继承了一个抽象方法
9interface Base {
10    void doBase();
11}
12
13@FunctionalInterface
14interface Child extends Base {
15    void doChild();  // ❌ 现在有两个抽象方法了！（Base 的 + 自己的）
16}

1// ✅ 正确：继承的方法如果也是抽象方法，总数超过 1 就不行
2// ✅ 但如果继承的是 default 方法，那就不算抽象方法
3@FunctionalInterface
4interface Good extends Base2 {
5    // Base2 里有一个 default 方法 → 不算抽象方法
6    // 所以这里只有一个抽象方法 → 合法
7    void doSomething();
8}

1// 看起来没问题，但编译通不过
2@FunctionalInterface
3interface Processor {
4    void process(int x);
5    // 三个月后，同事在这加了一行：
6    void process(String x);  // ❌ 立马编译报错，帮你拦截
7    // 如果没有 @FunctionalInterface，这里悄无声息地多了一个抽象方法，
8    // 原来 Lambda 写法全部炸掉，排查到天荒地老
9}

1// 表面看差不多
2Runnable r1 = () -> System.out.println("Lambda");
3Runnable r2 = new Runnable() {
4    @Override
5    public void run() { System.out.println("匿名内部类"); }
6};
7
8// 但：
9// r1.getClass() → 类似 com.xxx.Main$$Lambda$1/0x000000...
10// r2.getClass() → 类似 com.xxx.Main$1
11// r1.getClass().getDeclaredFields() → 空
12// r2.getClass().getDeclaredFields() → 可能有外部类引用

1// ❌ 错误：用 Lambda 实现非函数式接口
2// 比如想用 Lambda 创建 Thread（其实可以，Runnable 是函数式接口）
3// 但如果自己写了个双方法接口：
4interface Worker {
5    void work();
6    void rest();  // 第二个抽象方法
7}
8
9// Worker w = () -> System.out.println("work");  // ❌ 编译错误！
10// 编译器不知道你实现的是 work 还是 rest

1// ❌ 常见陷阱：Lambda 里 this 是外层类
2public class Outer {
3    void test() {
4        Runnable r = () -> System.out.println(this);  // this = Outer 实例
5        r.run();
6    }
7}
8// 在匿名内部类里，this = 匿名类本身

1// 1️⃣ 参数类型可以省略（编译器靠函数式接口推断）
2// 写完整版：
3Predicate<String> p1 = (String s) -> s.length() > 3;
4// 省略类型：
5Predicate<String> p2 = s -> s.length() > 3;
6
7// 2️⃣ 单参数可以省略括号
8Consumer<String> c = s -> System.out.println(s);  // ✅
9// 但 0 参数或 2+ 参数必须加括号：
10Supplier<String> sup = () -> "hello";       // ✅ 必须括号
11BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;  // ✅ 必须括号
12
13// 3️⃣ 单行函数体可以省略 {} 和 return
14Function<Integer, String> f1 = i -> { return String.valueOf(i); };  // 完整版
15Function<Integer, String> f2 = i -> String.valueOf(i);              // 省略版 ✅
16
17// 多行必须写 {} 和 return：
18Function<Integer, String> f3 = i -> {
19    System.out.println("debug: " + i);  // 多行
20    return String.valueOf(i);
21};

1// ❌ 错误：多行却省略 return
2Function<Integer, String> f = i -> {
3    String s = "prefix_" + i;
4    s;  // ❌ 这是表达式语句，不是 return！
5};
6// 编译器会报：not a statement 或 missing return statement
7
8// ❌ 错误：0 参数省略了括号
9// Supplier<String> s = -> "hello";  // ❌ 不行，必须 ()
10Supplier<String> s = () -> "hello";  // ✅
11
12// ❌ 错误：参数类型一部分省一部分不省
13// BiFunction<Integer, Integer, Integer> add = (int a, b) -> a + b;  // ❌ 要么全写要么全省
14BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;  // ✅

1// ❌ 常见陷阱：省略花括号时无意中改变了语义
2// 你以为这样是 { print; return; }：
3Consumer<String> c = s -> System.out.println(s); // ✅ 正确
4
5// 但如果写成：
6// Runnable r = () -> System.out.println("hello");  // 这其实没有 return
7// 跟 Runnable 的 void run() 刚好匹配，所以可以
8// 但如果是 Function，必须有 return 值

1// 1️⃣ 接口有多个抽象方法（非函数式接口）
2// 必须用匿名内部类：
3WindowListener listener = new WindowListener() {
4    @Override public void windowOpened(WindowEvent e) {}
5    @Override public void windowClosing(WindowEvent e) {}
6    // ... 其他方法
7};
8
9// 2️⃣ 需要自己的实例状态（字段）
10// Lambda 里不能声明实例字段：
11Runnable r = new Runnable() {
12    private int count = 0;  // ✅ 匿名内部类可以
13    @Override
14    public void run() {
15        count++;
16    }
17};
18// Lambda 写法拿不到 this 的字段
19
20// 3️⃣ 需要 this 指向自己（比如用在递归或自引用场景）
21// 匿名内部类：this = 自己
22// Lambda：this = 外层类
23
24// 4️⃣ 创建抽象类的实例
25// 抽象类不能用于 Lambda（Lambda 只认接口）：
26ActionListener l = new ActionListener() { // ✅ 匿名内部类
27    @Override
28    public void actionPerformed(ActionEvent e) {}
29};

1// ❌ 经典错误：在 Lambda 里用 this 引用自己
2// 场景：一个按钮点击后把自己 disable
3Button btn = new Button();
4btn.setOnAction(e -> {
5    // this 不是 btn！this 是外层类！
6    // this.setDisable(true);  // ❌ 编译错误 or 错对象
7    btn.setDisable(true);     // ✅ 直接引用外部变量
8});
9
10// 对比匿名内部类：
11btn.setOnAction(new EventHandler<ActionEvent>() {
12    @Override
13    public void handle(ActionEvent event) {
14        // this 指向匿名内部类，也不是 btn！
15        // 所以这个场景下两者 this 都不指向 btn，需要显式引用外部变量
16    }
17});

1// ③ 类的实例方法引用：第一个参数成为方法调用者
2// 函数式接口：BiFunction<String, String, Integer>
3// 抽象方法：Integer apply(String t, String u)
4// 方法引用：String::indexOf
5// 效果：(t, u) -> t.indexOf(u)   ← t 成了"调用者"，u 是参数
6
7BiFunction<String, String, Integer> f = String::indexOf;
8int result = f.apply("Hello", "el");  // = "Hello".indexOf("el") = 1

1// 另一个经典例子
2// Stream 中：names.stream().map(String::toUpperCase)
3// map 的参数是 Function<String, String>，即 String apply(String s)
4// String::toUpperCase 是"类的实例方法引用"，
5// 接收一个 String（即 s），调用 s.toUpperCase()
6List<String> upper = names.stream().map(String::toUpperCase).collect(...);

1// ❌ 错误：参数不匹配
2// Predicate<String> 的 test 方法：boolean test(String s)
3// String::isEmpty 是 boolean isEmpty()（无参数）
4// 签名匹配 → 可以用！因为 String::isEmpty 的隐含参数就是调用者本身
5Predicate<String> p = String::isEmpty;  // ✅ 其实合法！等价于 s -> s.isEmpty()
6
7// ❌ 错误：返回类型不匹配
8// Consumer<String> 的 accept 方法：void accept(String s)
9// String::toUpperCase 返回 String，不是 void
10// Consumer<String> c = String::toUpperCase;  // ❌ 编译错误！
11// 应该用 Function<String, String> f = String::toUpperCase;

1// ❌ 错误：构造器引用匹配错了
2// Supplier<Person> 的 get()：无参数，返回 Person
3Supplier<Person> s = Person::new;  // ✅ 调用 Person() 无参构造
4
5// Function<String, Person> 的 apply(String)：一个参数，返回 Person
6Function<String, Person> f = Person::new;  // ✅ 调用 Person(String name)
7
8// BiFunction<String, Integer, Person>：两个参数
9BiFunction<String, Integer, Person> bf = Person::new;  // ✅ 调用 Person(String, Integer)
10// 构造函数的重载选择完全由函数式接口的参数列表决定！

1// ✅ effectively final
2int x = 10;
3Runnable r = () -> System.out.println(x);
4
5// ❌ 不是 effectively final
6int y = 10;
7y = 20;  // 重新赋值了
8// Runnable r2 = () -> System.out.println(y);  // ❌ 编译错误

1// ❌ 经典错误：在循环里用 Lambda
2for (int i = 0; i < 3; i++) {
3    // Runnable r = () -> System.out.println(i);  // ❌ 编译错误！
4    // i 不是 effectively final（i++ 了两次）
5}
6
7// ✅ 正确做法：拷贝一份
8for (int i = 0; i < 3; i++) {
9    int copy = i;  // copy 是 effectively final
10    Runnable r = () -> System.out.println(copy);  // ✅
11}

1// ❌ 错误：数组元素的引用问题（初学者最常踩的坑）
2int[] sum = {0};
3Arrays.asList(1, 2, 3).forEach(n -> sum[0] += n);  // ✅ 合法！
4// 等等，不是说不能改吗？注意：sum 这个引用没有变（仍是同一个数组），
5// 变的只是数组的内容。final 限制的是"变量本身"，不是"变量指向的对象内部状态"。
6// 这其实是个坏实践——如果你在并行流里这么做，就会出现竞态条件！

1// ❌ 并行流中的共享可变状态（实际开发中出 bug 的常见原因）
2int[] total = {0};
3list.parallelStream().forEach(n -> total[0] += n);
4// ⚠️ 竞态条件！结果不确定。正确做法：用 reduce 或 AtomicInteger

1public class ScopeDemo {
2    private int member = 10;           // 成员变量
3    private static int staticVar = 20;  // 静态变量
4
5    public void test() {
6        int local = 30;  // 局部变量
7
8        Runnable r = () -> {
9            System.out.println(member);     // ✅ 可读
10            member++;                        // ✅ 可写（但要处理并发问题）
11            System.out.println(staticVar);  // ✅ 可读
12            staticVar++;                     // ✅ 可写
13            System.out.println(local);      // ✅ 可读
14            // local++;                      // ❌ 不可写！不是 effectively final
15        };
16    }
17}

1// ❌ 混淆：以为"静态变量也在方法区，为啥能改"
2// 静态变量不在栈上，在方法区（或元空间），Lambda 通过 Class 直接访问，
3// 不涉及拷贝，不违反一致性逻辑。

1// 每个接口一行实战代码
2Predicate<String> isEmpty = String::isEmpty;            // 断言
3Function<String, Integer> len  = String::length;        // 转换
4Supplier<Double> random       = Math::random;           // 生产
5Consumer<String> printer      = System.out::println;    // 消费

1// ❌ 错误：Function 用错了方向
2// Function<Integer, String> 意思是：接收 Integer，返回 String
3Function<Integer, String> f = String::valueOf;  // ✅ int → String
4// 反过来就错了：
5// Function<String, Integer> f2 = String::valueOf;  // ❌ String → String? 不对！valueOf 返回 String
6
7// ❌ 错误：把 Consumer 当 Function 用
8// Consumer<String> c = String::toUpperCase;  // ❌ toUpperCase 返回 String，不是 void
9Consumer<String> c = System.out::println;     // ✅ println 返回 void

1Function<Integer, Integer> f = x -> x + 1;   // f(x) = x + 1
2Function<Integer, Integer> g = x -> x * 2;   // g(x) = x * 2
3
4// compose：参数函数先执行，自己的函数后执行
5Function<Integer, Integer> h1 = g.compose(f);
6// h1(x) = g(f(x)) = g(x+1) = (x+1)*2
7// compose 里 f 在"前"（先跑）
8
9// andThen：自己的函数先执行，参数函数后执行
10Function<Integer, Integer> h2 = g.andThen(f);
11// h2(x) = f(g(x)) = f(x*2) = x*2 + 1
12// andThen 里 f 在"后"（后跑）
13
14// 数值验证：
15h1.apply(3);  // (3+1)*2 = 8
16h2.apply(3);  // 3*2+1   = 7

1// 链式模拟数学：h(x) = sqrt( abs(x) ) + 1
2// 即 h(x) = add1( sqrt( abs(x) ) )
3// 函数分解：abs → sqrt → add1
4Function<Double, Double> h =
5    ((Function<Double, Double>) Math::abs)    // abs
6    .andThen(Math::sqrt)                       // 然后 sqrt
7    .andThen(x -> x + 1);                      // 然后 +1
8// andThen 可以一直链下去，compose 也可以但不太自然

1// ❌ 常见错误：方向搞反了
2// 需求：先 trim 再转大写
3Function<String, String> trim = String::trim;
4Function<String, String> upper = String::toUpperCase;
5
6Function<String, String> wrong = trim.andThen(upper);     // ✅ 正确：先 trim 后 upper
7Function<String, String> also = upper.compose(trim);      // ✅ 也正确：先 trim 后 upper
8// 两者结果一样：trim→upper
9
10// 混淆时刻：
11Function<String, String> bug = upper.andThen(trim);       // 先 upper 后 trim（可能不是你想要的）
12// " hello " → upper → " HELLO " → trim → " HELLO"？不对 trim 只去首尾空格，先去空格再大写才有意义

1// 传统写法：返回值类型看不出是否可能为 null
2public User findUser(String name) {
3    // 返回 null 还是空 User？调用方不看文档就不知道
4    return null;
5}
6
7// Optional 写法：签名自己说清楚了 —— "结果有可能没有"
8public Optional<User> findUser(String name) {
9    return Optional.ofNullable(db.get(name));
10}
11// 调用方：必须显式处理空值，否则拿不到里面的 User
12User user = findUser("张三").orElse(User.GUEST);

1// ❌ 最致命的反模式：把 Optional 本身当 null 用
2public Optional<User> findUser(String name) {
3    if (name == null) return null;  // ❌❌❌ 绝对不要这样！
4    // Optional 方法返回 null 等于双重 null，调用方的 orElse 全白费
5    return Optional.empty();  // ✅ 这才是对的
6}
7
8// ❌ 反模式：用 isPresent() + get() 代替 orElse
9Optional<User> opt = findUser("张三");
10if (opt.isPresent()) {          // ❌ 这是传统 null 检查的翻版，没发挥 Optional 优势
11    User user = opt.get();      // ❌ isPresent + get = 和 if(x != null) 没区别
12    // ...
13}
14// ✅ 正确：
15findUser("张三").ifPresent(user -> { /* ... */ });
16// 或
17User user = findUser("张三").orElse(User.GUEST);
18
19// ❌ 反模式：Optional 作为方法参数
20public void process(Optional<User> user) {  // ❌ 别这样设计 API
21    // 调用方传来的 Optional 可能是 null → 你的代码就炸了
22}
23// ✅ Optional 只应该作为返回值类型，不推荐作为参数或字段

1// ❌ 经典错误：of() vs ofNullable()
2Optional<String> opt1 = Optional.of(null);       // ❌ NullPointerException！
3Optional<String> opt2 = Optional.ofNullable(null); // ✅ 返回 Optional.empty()
4// 规则：确定不为空用 of；不确定用 ofNullable

1Optional<User> user = findUser("张三");
2// map：User → String → Optional<String>
3Optional<String> name = user.map(User::getName);
4// flatMap：当转换函数自身也返回 Optional 时，避免 Optional<Optional<T>>
5// flatMap：User → Optional<Address> → Optional<Address>（拍平）
6Optional<Address> addr = user.flatMap(User::getAddress);
7// 如果 User.getAddress() 返回 Optional<Address>，
8// 用 map 会得到 Optional<Optional<Address>>，用 flatMap 得到 Optional<Address>

1// orElse：不管 Optional 有没有值，expensiveDefault() 都会执行
2String s1 = opt.orElse(expensiveDefault());  // ❌ 浪费
3
4// orElseGet：只有缺失时才执行 expensiveDefault()
5String s2 = opt.orElseGet(() -> expensiveDefault());  // ✅

1// ========== 创建 ==========
2Optional.empty()              // 空 Optional
3Optional.of(value)            // 非空值（null 则 NPE）
4Optional.ofNullable(value)    // 允许 null，null 变成 empty
5
6// ========== 取值 ==========
7opt.get()                     // ⚠️ 不安全，empty 时抛异常
8opt.orElse(default)           // 有值返回值，否则返回默认值
9opt.orElseGet(() -> ...)      // 惰性默认值
10opt.orElseThrow()             // 有值返回值，否则抛 NoSuchElementException
11opt.orElseThrow(() -> new X)  // 自定义异常
12
13// ========== 判空执行 ==========
14opt.isPresent()               // 有值返回 true
15opt.isEmpty()                 // JDK11+：空返回 true
16opt.ifPresent(v -> ...)       // 有值则消费
17opt.ifPresentOrElse(v -> ..., () -> ...)  // JDK9+：有值/无值双处理
18
19// ========== 链式转换 ==========
20opt.map(v -> ...)             // 有值时转换，返回 Optional
21opt.flatMap(v -> ...)         // 和 map 一样但自动拍平
22opt.filter(v -> condition)    // 有值且满足条件才保留，否则 empty
23
24// ========== 流转换（JDK9+）==========
25opt.stream()                  // 变成 0 或 1 个元素的 Stream

1names.stream()                 // 获取数据源
2    .filter(n -> n != null)    // 描述步骤1：去空
3    .map(String::toUpperCase)  // 描述步骤2：转大写
4    .sorted()                  // 描述步骤3：排序
5    .collect(toList());        // 触发执行，输出结果

1// ❌ 经典错误：复用已消费的 Stream
2Stream<String> stream = list.stream().filter(s -> s.length() > 3);
3long count = stream.count();        // ✅ 第一次消费
4// long count2 = stream.count();    // ❌ IllegalStateException: stream has already been operated upon or closed
5
6// ✅ 正确：需要多次用时重新获取
7long count1 = list.stream().filter(s -> s.length() > 3).count();
8long count2 = list.stream().filter(s -> s.length() > 3).count();
9
10// ❌ 错误：在 Stream 操作中修改源数据
11List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
12// list.stream().forEach(s -> list.add(s + "!"));  // ⚠️ 可能 ConcurrentModificationException
13// Stream 不应该在操作过程中修改源数据，尤其在并行流中是灾难

1// ❌ 常见误会：以为中间操作改了源集合
2List<String> list = new ArrayList<>(Arrays.asList("b", "a", "c"));
3list.stream().sorted().collect(toList());  // 返回新 List
4System.out.println(list);  // [b, a, c] —— 原集合没变！sorted 只是视图排序

1// 斐波那契无限流（只取前10个）
2Stream.iterate(new int[]{0, 1}, f -> new int[]{f[1], f[0] + f[1]})
3    .limit(10)
4    .map(f -> f[0])
5    .forEach(System.out::println);

1// ❌ 经典错误：没有终端操作，什么都不执行
2list.stream()
3    .filter(s -> { System.out.println("filter: " + s); return true; })
4    .map(s -> { System.out.println("map: " + s); return s; });
5// 控制台空空如也！因为没加终端操作，整个管道没被"点火"
6
7// ✅ 加个终端操作：
8list.stream()
9    .filter(s -> { System.out.println("filter: " + s); return true; })
10    .map(s -> { System.out.println("map: " + s); return s; })
11    .collect(toList());  // ← 点火！现在控制台有输出了

1// ❌ 错误：终端操作后还想继续流操作
2Stream<String> s = list.stream();
3s.filter(...).collect(toList());  // ✅
4// s.map(...)                      // ❌ 流已经消费了

1// 直观理解：排序必须全部看完才能确定第一个
2// 如果给你 1, 5, 3, 2 四个数
3// filter(x > 2)：来一个判一个，x=1 直接丢 → 流式 ✅
4// sorted()：看完 1,5,3,2 才知道排序后是 1,2,3,5 → 非流式 ❌（得全量缓存）

1// ⚠️ 性能陷阱：大文件行排序
2// 如果文件有 10GB，stream 里 sorted() 会把所有行读到内存 → OOM
3Files.lines(Paths.get("huge.log"))   // 惰性读取
4    .sorted()                         // ❌ 读进内存，可能 OOM
5    .forEach(System.out::println);
6
7// ✅ 正确：大文件排序用外部排序，或数据库排序，或先 limit 再 sorted

1// ❌ 顺序误区：先 sorted 再 filter vs 先 filter 再 sorted
2list.stream()
3    .sorted()       // 排序全部
4    .filter(...)    // 过滤掉大部分
5    .collect(...);
6// 不如：
7list.stream()
8    .filter(...)    // 先过滤掉大部分
9    .sorted()       // 只排序剩下的 ← 更高效！
10// 原则：先 filter 缩小数据集，再做 sorted / distinct 等有状态操作

1// 列表：[1, 2, 3, 4, 5, 6, 7, 8]
2list.parallelStream()
3    .map(x -> x * 2)
4    .reduce(0, Integer::sum);
5
6// 内部大致流程：
7// Step 1: Fork（拆分）
8//   [1,2,3,4,5,6,7,8] → [1,2,3,4] + [5,6,7,8]
9//   → [1,2] + [3,4]   +   [5,6] + [7,8]
10// Step 2: Process（并行处理）
11//   四个线程分别处理 [1,2] [3,4] [5,6] [7,8]
12//   → (2,4) (6,8) (10,12) (14,16)
13// Step 3: Join（合并）
14//   → (2+4+6+8) + (10+12+14+16) = 20 + 52 = 72

1// ❌ 错误：在并行流内使用非线程安全的集合
2List<Integer> results = new ArrayList<>();  // 不是线程安全的！
3list.parallelStream()
4    .map(x -> x * 2)
5    .forEach(results::add);   // ❌ 竞态条件！可能丢数据或抛异常
6// ✅ 用 collect：
7List<Integer> safe = list.parallelStream()
8    .map(x -> x * 2)
9    .collect(toList());        // ✅ 线程安全
10// ✅ 或用线程安全容器：
11List<Integer> results = Collections.synchronizedList(new ArrayList<>());
12
13// ❌ 错误：并行流里用了有状态的 Lambda
14int[] sum = {0};  // ❌ 竞态条件
15list.parallelStream().forEach(n -> sum[0] += n);

1// ❌ 错误：在公共 ForkJoinPool 中执行阻塞操作
2list.parallelStream().forEach(item -> {
3    // Thread.sleep(1000);  // ❌ 占用公共线程池线程，影响全局
4});
5// 公共线程池被阻塞 → JVM 中所有用到 parallelStream 的地方都受影响

1ForkJoinPool customPool = new ForkJoinPool(4);
2customPool.submit(() ->
3    list.parallelStream().forEach(...)
4).get();
5// 这会使用自定义池而不是公共池

1// 旧写法（3行）
2if (!map.containsKey(key)) {
3    map.put(key, value);
4}
5// 新写法（1行）
6map.putIfAbsent(key, value);

1// 经典场景：分组 + 计数 / 分组 + 列表
2Map<String, List<User>> byCity = new HashMap<>();
3for (User u : users) {
4    byCity.computeIfAbsent(u.getCity(), k -> new ArrayList<>())
5          .add(u);
6}
7// 内部逻辑：如果 city 不在 map 中，执行 Lambda 创建 ArrayList，放入 map，返回它
8// 如果 city 已存在，直接返回已有的 List
9
10// 旧写法（需要 if + put，至少 5 行）：
11List<User> list = byCity.get(u.getCity());
12if (list == null) {
13    list = new ArrayList<>();
14    byCity.put(u.getCity(), list);
15}
16list.add(u);

1// 场景：对购物车里的商品数量翻倍
2map.computeIfPresent(key, (k, v) -> v * 2);
3// 如果 key 存在，用新值替换；如果不存在，什么都不做

1// 场景：计数累加
2wordCounts.merge(word, 1, Integer::sum);
3// key 不存在 → 放 1
4// key 存在 → sum(old, 1) = old+1
5
6// 场景：合并两个 Map
7map2.forEach((k, v) -> map1.merge(k, v, Integer::sum));

1map.getOrDefault(key, defaultValue);          // 不存在给默认值
2map.remove(key, value);                       // k 且 v 都匹配才删
3map.replace(key, value);                      // 存在则替换
4map.replace(key, oldValue, newValue);         // k 且 v 都匹配才替换

1// ❌ 错误：computeIfAbsent 里又去改同一个 map（可能导致 ConcurrentModificationException）
2map.computeIfAbsent(key, k -> {
3    // map.put("other", "value");  // ❌ 别！在 compute 函数里修改 map 是不安全的
4    return "value";
5});
6
7// ❌ 错误：merge 的 remapping 函数返回 null
8map.merge(key, 1, (oldV, newV) -> null);
9// 如果 remapping 函数返回 null，会删除该 key！这是 merge 的特殊行为
10
11// ❌ 常见误解：putIfAbsent 返回什么？
12String old = map.putIfAbsent("key", "newValue");
13// 如果 key 已经存在 → 返回已有的 value
14// 如果 key 不存在 → 返回 null
15// 容易误以为返回"将要被 put 的值"

1Map<String, Integer> map = ...;
2
3// 三种视图各自都可以用 Stream：
4map.keySet().stream()      // Stream<String>  → 对 key 操作
5map.values().stream()      // Stream<Integer> → 对 value 操作
6map.entrySet().stream()    // Stream<Map.Entry<String, Integer>> → 对 key+value 操作
7
8// 实用例子：
9// 过滤出 value > 10 的 key
10List<String> keys = map.entrySet().stream()
11    .filter(e -> e.getValue() > 10)
12    .map(Map.Entry::getKey)
13    .collect(toList());
14
15// 把 Map 转成另一个 Map
16Map<String, Integer> doubled = map.entrySet().stream()
17    .collect(toMap(Map.Entry::getKey, e -> e.getValue() * 2));

1// 1️⃣ 可变 → 线程不安全
2Date d = new Date();
3d.setTime(1000);  // 原对象被改了！
4
5// 2️⃣ 偏移量诅咒：月份从 0 开始
6Date d = new Date(2024, 1, 1);  // 你以为 2024-01-01？
7// 实际是 3924-02-01！（年份 = 1900+2024，月份 1=2月）
8
9// 3️⃣ SimpleDateFormat 线程不安全！
10SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
11// 多线程共享同一个 sdf 实例 → 解析结果错乱，甚至抛异常
12
13// 4️⃣ 命名混乱
14Date d = new Date();          // 包含日期+时间，但叫"Date"
15Date d2 = new Date(0);        // 也是日期+时间

1// 每个类只做一件事，名字说清楚
2LocalDate date = LocalDate.of(2024, 1, 1);    // 只有日期，月份终于从 1 开始
3LocalTime time = LocalTime.of(10, 30);         // 只有时间
4LocalDateTime dt = LocalDateTime.of(date, time); // 日期+时间
5ZonedDateTime zdt = ZonedDateTime.now();        // 带时区
6Instant instant = Instant.now();               // 机器时间戳
7
8// 所有修改都返回新对象
9LocalDate tomorrow = date.plusDays(1);  // date 本身没变
10LocalDate nextMonth = date.plusMonths(1); // 又一个新对象

1// ❌ 老代码常见错误：共享 SimpleDateFormat
2public class DateUtils {
3    private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd");
4    // 多线程共享 → ❌ 线程安全问题！！！
5
6    public static String format(Date d) {
7        return SDF.format(d);  // ❌ 并发调用会挂
8    }
9}
10
11// ✅ 新写法：
12public class DateUtils {
13    private static final DateTimeFormatter FMT =
14        DateTimeFormatter.ofPattern("yyyy-MM-dd");
15    // DateTimeFormatter 不可变，线程安全 ✅
16
17    public static String format(LocalDate d) {
18        return FMT.format(d);
19    }
20}

1// ❌ 常见错误：LocalDateTime 不带时区，跨国业务直接用会出问题
2LocalDateTime dt = LocalDateTime.now();  // 拿的是服务器本地时间
3// 如果服务器在上海，用户在美国，这个时间对用户来说无意义
4
5// ✅ 跨时区用 ZonedDateTime 或 Instant
6Instant instant = Instant.now();  // UTC 时间，全球通用
7ZonedDateTime userTime = instant.atZone(ZoneId.of("America/New_York"));

1// Date → Instant → LocalDateTime
2Date oldDate = new Date();
3LocalDateTime dt = oldDate.toInstant()
4    .atZone(ZoneId.systemDefault())
5    .toLocalDateTime();
6
7// LocalDateTime → Instant → Date
8Date newDate = Date.from(
9    LocalDateTime.now()
10        .atZone(ZoneId.systemDefault())
11        .toInstant()
12);

1Period period = Period.between(date1, date2);     // P3M5D
2Duration duration = Duration.between(time1, time2); // PT2H30M

1// JDK7 及以前：想打多个 @Role → 必须用容器注解包起来
2@Roles({                       // 容器注解
3    @Role("admin"),
4    @Role("user")
5})
6public class User {}
7
8// JDK8：可以直接写多个同名注解
9@Role("admin")
10@Role("user")
11public class User {}

1// 反射获取时，直接用 getAnnotationsByType
2Role[] roles = User.class.getAnnotationsByType(Role.class);
3// 也能通过 getAnnotation(Roles.class) 获取容器，但不推荐

1// 可重复的注解
2@Repeatable(Roles.class)  // 指定容器
3@interface Role {
4    String value();
5}
6
7// 容器注解
8@interface Roles {
9    Role[] value();  // 必须是 value()，且类型是重复注解的数组
10}

1// ❌ 错误：容器注解的 value() 属性的类型写错
2@Repeatable(Roles.class)
3@interface Role { String value(); }
4
5@interface Roles {
6    // ❌ 错误：
7    // String[] value();  // 必须是 Role[]，不是其他类型
8    Role[] value();       // ✅ 正确
9}
10
11// ❌ 错误：容器注解的成员名必须是 value（编译器约定）
12@interface Roles {
13    // Role[] roles();  // ❌ 不能用其他名字
14    Role[] value();      // ✅ 必须叫 value
15}

1// ❌ 常见错误：只获取容器注解而忽略了重复注解
2// Roles roles = cls.getAnnotation(Roles.class);  // JDK7 方式，能用但笨拙
3// ✅ 新 API：
4Role[] roles = cls.getAnnotationsByType(Role.class);  // JDK8 方式

1// TYPE_PARAMETER：只能标类型参数的声明
2class Container<@MyAnnotation T> {}  // 标在 T 的声明上
3
4// TYPE_USE：标在类型使用的任何地方
5@MyAnnotation String name;                          // 字段声明
6String s = (@MyAnnotation String) obj;              // 强制转换
7new @MyAnnotation ArrayList<>();                    // 对象创建
8List<@MyAnnotation String> list;                    // 泛型参数